\section{Desarrollo}

En esta sección se detallan las tareas llevadas a cabo para la realización de este trabajo. Se comienza explicando el análisis teórico realizado sobre la serie de Maclaurin y el error cometido al calcularla. Luego, se explica la implementación que se ha realizado y un problema que hemos encontrado a la hora de probar la implementación.

\subsection{Serie de Maclaurin}

Cómo se ha mencionado con anterioridad, uno de los métodos utilizados para el cálculo de la función \textit{coseno} es el que utiliza la serie de Maclaurin. La serie de Maclaurin no es más que la serie de Taylor para la función \textit{coseno} centrada en el cero.

Sin embargo, es imposible calcular los infinitos términos de una serie cualquiera, en particular los de la serie de Maclaurin para el \textit{coseno}. Es por este motivo que se debe aproximar la misma. Para ello, se reemplaza la serie por una sumatoria hasta un cierto valor $n$ y se realiza la suma hasta ese valor $n$ seleccionado.

\subsection{Aproximacion de la Serie de MacLaurin}

Cómo se mencionó en la sección anterior, la serie de Maclaurin de la función \textit{coseno} se aproxima mediante una sumatoria de $n$ términos. Cómo la serie converge al valor exacto de la función \textit{coseno}, con cada término adicional que se suma, se reduce el error de la aproximación de la serie; por consiguiente, el de la función \textit{coseno}.

En la práctica, para poder utilizar esta aproximación es necesario conocer el error que se comete al sumar solamente $n$ términos. Así mismo, ciertas aplicaciones tienen cotas máximas sobre el error que pueden tolerar, y en este caso es necesario conocer la cantidad mínima de términos que se deben sumar para que el error de la aproximación se encuentre dentro de los parámetros necesarios.

\subsection{Error de la Aproximación de la Serie de Maclaurin}

En esta sección se calcula el error cometido al aproximar la serie de Maclaurin de la función \textit{coseno} mediante una suma de $n$ términos.

Cómo la serie de Maclaurin es un caso particular de la serie de Taylor, se puede utilizar el resto de Lagrange del Teorema de Taylor para calcular el error cometido al aproximar la función por un polinomio de grado $n$ \cite{Bartle}. Donde $n$ es la cantidad de términos que se ha decidido sumar.

En el caso analizado existe sin embargo una particularidad, la misma radica en que el polinomio de Maclaurin para la función \textit{coseno} de grado $n$ es equivalente al polinomio de Lagrange de grado $2n$. Esto se debe a que todas las derivadas impares son $\sin(x)$, o $-\sin(x)$; y al ser evaluadas en cero, las mismas se anulan. Por este motivo, la mitad de los términos del polinomio de Taylor de la función \textit{coseno} evaluado en cero se anulan. Esto es importante debido a que el resto de Lagrange debe ser de grado uno más que el último término del polinomio de Taylor correspondiente, por lo cual se debe calcular el resto de grado $2n + 1$.

\subsubsection{Cota del Error}

La serie de Maclaurin para la función \textit{coseno} es:

\begin{equation*}
  y(x) = \sum^{\infty}_{i=0} \frac{(-1)^i}{(2i)!} x^{2i}
\end{equation*}

\subsubsection{Error de Truncamiento de la Serie de Maclaurin}

La fórmula del resto de Lagrange de orden $2n + 1$ para acotar el error cometido al aproximar la serie de Maclaurin de la función \textit{coseno} por una sumatoria de $n$ términos es:
 
\begin{equation}
	\frac{f^{(2n+1)}(c)}{(2n+1)!} x^{(2n+1)}
\end{equation}

donde $f^{(2n+1)}$ es la derivada de orden $2n+1$ de la función \textit{coseno}, con $c$ entre $0$ y $x$, $x$ al estar expresado en radianes es un valor entre $0$ y $2\pi$
\\
entonces la derivada $2n+1$ésima de \textit{coseno} es:
\\
\\
$	si \quad (2n+1) \% 4 == 0 \Rightarrow +cos(c)\\
	si \quad (2n+1) \% 4 == 1 \Rightarrow -sen(c)\\
	si \quad (2n+1) \% 4 == 2 \Rightarrow -cos(c)\\
	si \quad (2n+1) \% 4 == 3 \Rightarrow +sen(c)\\
$
\\
Entonces el error es:

\begin{equation}
	\left| \frac{f^{(2n+1)}(c)}{(2n+1)!} x^{2(n+1)} \right| = 
	\left| f^{(2n+1)}(c) \right| \left| \frac{x^{(2n+1)}}{(2n+1)!} \right| = 
\end{equation}

Se puede acotar el resto de Lagrange sabiendo que:

\begin{equation*}
	0 < c < x \hspace*{0.2cm} \wedge \hspace*{0.2cm} 0 \leq x \leq 2\pi \Longrightarrow 0 \leq c \leq 2\pi
\end{equation*}

Las funciones \textit{seno} o \textit{coseno} se pueden acotadar por 1, entonces queda:\\

\begin{equation}
	\begin{split}
		R_n(x) & \leq 1\left| \frac{x^{(2n+1)}}{(2n+1)!} \right| 
				\\& \leq \left| \frac{x^{(2n+1)}}{(2n+1)!} \right|
	\end{split}
\end{equation}

También se cumple que:

\begin{equation}
	\lim_{n\to\infty} \left| \frac{x^{(2n+1)}}{(2n+1)!} \right| = 0
\end{equation}

Lo cual quiere decir que al aumentar la cantidad de términos el error tiende a $0$, o sea que la serie aproxima a la función por completo con infinitos términos.


\subsubsection{Errores de Representación}

Cómo se mencionó anteriormente, otro problema que suele surgir al querer calcular la serie es la necesidad de trabajar con números de punto flotante\cite{IEEE754}. Esta representación de los números reales en una computadora no puede representar correctamente a todos los números reales, lo que suele introducir errores de representación en los cálculos.

La precisión nativa del tipo Double tiene una mantisa de 52-bits, y se utiliza redondeo en cada operación que se realiza, con la consecuente pérdida de precisión. Al realizar operaciones una después de otra, que es lo que se hace para calcular la serie de Maclaurin de la función \textit{coseno}, se arrastra el error de cada paso anterior, el cual puede aumentar o no, dependiendo del órden en el que se realizan las operaciones y de cuales son las operaciones que se realizan. Es por este motivo, que es importante analizar la propagación de los errores de precisión numérica cuando se trabaja con aritmética finita.

\subsubsection{Análisis de la Propagación del Error}

La serie de Maclaurin de la función \textit{coseno} se puede reescribir como:

\begin{equation*}
  y(x) = \sum^{n}_{i=0} t_{i}(x) \quad donde \quad t_{i}(x) = (-1)^i\frac{x^{2i}}{(2i)!}
\end{equation*}


\paragraph{Cota de $t_{i}(x)$:}

El signo de cada término $t_{i}$ se puede calcular con un simple $\textbf{if}$, lo cual no influye en el error y no tiene sentido analizarlo, entonces cada término $t_{i}(x)$ queda como:


\begin{equation*}
  t_{i}(x) = \frac{x^{2i}}{(2i)!} =
  			\frac{(xx)^i}{(2i)!} =
  			\frac{(xx)}{(2i)(2i-1)} \frac{(xx)}{(2i-2)(2i-3)} ... \frac{(xx)}{4*3} \frac{(xx)}{2*1} =
  			\prod^{i}_{k=1} \frac{(xx)}{(2k)(2k-1)} =
  			\prod^{i}_{k=1} ts_{k}(x)
\end{equation*}

con $ts_{k}(x) = \frac{(xx)}{(2k)(2k-1)}$

\subparagraph{Cota de $ts_{k}(x)$:}

$ts_{k}(x)$ es un cociente entonces para acotar el error se puede aplicar la fórmula del error relativo de un cociente\cite{Germund}:

\begin{equation*}
	\left| \varepsilon\left(\frac{x}{y}\right) \right| \leq \vert \varepsilon_{x} \vert + \vert \varepsilon_{y} \vert + \vert \varepsilon_{div} \vert
\end{equation*}

Entonces:

\begin{equation*}
	\left| \varepsilon\left( \frac{(xx)}{(2k)(2k-1)} \right) \right| \leq \vert \varepsilon_{xx} \vert + \vert \varepsilon_{(2k)(2k-1)} \vert + \vert \varepsilon_{div} \vert
\end{equation*}

donde

\begin{equation*}
	\left| \varepsilon_{xx} \right| \leq \vert \varepsilon_{x} \vert + \vert \varepsilon_{x} \vert + \vert \varepsilon_{*} \vert = 2\vert \varepsilon_{x} \vert + \vert \varepsilon_{*} \vert
\end{equation*}

y $ \varepsilon_{(2k)(2k-1)} $ es 0 porque k es un natural y las operaciones con naturales se hacen de manera exacta, el único error que se puede producir es al castear el resultado (que es natural) a un flotante, por lo 
cual $ \varepsilon_{(2k)(2k-1)} $ se puede reemplazar por $ \varepsilon_{float} $

Entonces

\begin{equation*}
	\left| \varepsilon\left( ts_{k}(x) \right) \right| \leq 2\vert \varepsilon_{x} \vert + \vert \varepsilon_{*} \vert + \vert \varepsilon_{float} \vert + \vert \varepsilon_{div} \vert
\end{equation*}

Para mayor claridad y para acortar las fórmulas, vamos a acotar los errores relativos de las operaciones y los errores relativos de los datos de entrada por la cota que se deduce de como se representan los números flotantes en aritmética finita.
Al trabajar con aritmética finita se puede acotar los errores de operación por:
\\
si se usa truncamento:
\\
$\left| \varepsilon_{op} \right| \leq 2^{-t}$
\\
si se redondea:
\\
$\left| \varepsilon_{op} \right| \leq \frac{1}{2} 2^{-t}$
\\

Entonces la fórmula acotada quedaría:

\begin{equation*}
	\left| \varepsilon\left( ts_{k}(x) \right) \right| \leq 5\vert \varepsilon_{op} \vert
\end{equation*}


\subparagraph{Cota de $t_{i}(x)$ (continuación):}

Cómo $t_{i}(x)$ es un producto de términos $ts_{k}(x)$ se puede aplicar la fórmula del error relativo de producto de dos elementos\cite{Germund}:

\begin{equation*}
	\left| \varepsilon\left(x*y\right) \right| \leq \vert \varepsilon_{x} \vert + \vert \varepsilon_{y} \vert + \vert \varepsilon_{*} \vert
\end{equation*}

Aplicando esta fórmula de a dos elementos se obtiene que:

\begin{equation*}
	\begin{split}
		\left| \varepsilon_{ti(x)} \right| & \leq \left| \varepsilon_{ts_{k}(x)} \right|
		+
		\left| \varepsilon_{ts_{k}(x)} \right| +
		....
		+ \left| \varepsilon_{ts_{k}(x)} \right|
		+ \vert \varepsilon_{*} \vert + ... + \vert + \vert \varepsilon_{*} \vert
		\\& \leq 5\vert \varepsilon_{*} \vert + 5\vert \varepsilon_{*} \vert + ... +
		5\vert \varepsilon_{*} \vert + 
		\vert \varepsilon_{*} \vert + ... + \vert + \vert \varepsilon_{*} \vert
		\\& \leq 5i\vert \varepsilon_{*} \vert + (i-1)\vert \varepsilon_{*} \vert =
		(5i+i-1)\vert \varepsilon_{*} \vert = (6i-1)\vert \varepsilon_{*} \vert
	\end{split}
\end{equation*}

Entonces la cota del error relativo para el término $t_{i}(x)$ es:

\begin{equation}
	\left| \varepsilon_{ti(x)} \right| \leq (6i-1)\left| \varepsilon_{*} \right|
\end{equation}


\subparagraph{Cota total:}

Para calcular la cota general primero calculamos la fórmula del error relativo de una suma de $n$ términos.
Se propone la siguiente fórmula que será demostrada por inducción:

\begin{equation}
	\left| \varepsilon \left( \sum_{i=1}^{n} x_{i} \right) \right| \leq 
		\frac{ \sum_{i=1}^{n}\left|x_{i} \varepsilon_{xi}\right| + \sum_{i=2}^{n-1} \left| \varepsilon_{+i} \sum_{j=1}^{i} x_{j} \right| }
		{ \left| \sum_{i=1}^{n} x_{i} \right|}
		+
		\varepsilon_{+}
\end{equation}

La demostración se hace por inducción en $n$. El caso base es trivial $(n = 1)$, ahora demostramos el paso inductivo:
\\
Supongo que la propiedad vale para $n-1$ y quiero demostrar que vale para $n$. La suma hasta $n$ se puede escribir como:

\begin{equation}
	\sum_{i=1}^{n} x_{i} = \sum_{i=1}^{n-1} x_{i} + x_{n}
\end{equation}

Entonces aplicando la regla del error relativo de suma de dos elementos\cite{Germund}:

\begin{equation}
	\left| \varepsilon \left( \sum_{i=1}^{n} x_{i} \right) \right| \leq \left| \frac{\sum_{i=1}^{n-1} x_{i} * \varepsilon\left(\sum_{i=1}^{n-1} x_{i}\right)}{\sum_{i=1}^{n} x_{i}} \right| 
	+
	\left| \frac{x_{n}*\varepsilon\left(x_{n}\right)}{\sum_{i=1}^{n} x_{i}} \right| + \left| \varepsilon_{+} \right|
\end{equation}

Aplicando la hipótesis inductiva al error de la suma de $x_{i}$ que va hasta $n-1$:

\begin{equation}
	\begin{split}
	\left| \varepsilon \left( \sum_{i=1}^{n} x_{i} \right) \right| 
		&\leq \left| \frac{\sum_{i=1}^{n-1} x_{i} * 
			\frac{ \sum_{i=1}^{n-1}\left|x_{i}\varepsilon_{xi}\right| + \sum_{i=2}^{n-2} \left| \varepsilon_{+i} \sum_{j=1}^{i} x_{j} \right| }{ \sum_{i=1}^{n-1} x_{i} }
		+
		\varepsilon_{+}
	}
	{\sum_{i=1}^{n} x_{i}} \right| 
	+
	\left| \frac{x_{n}\varepsilon\left(x_{n}\right)}{\sum_{i=1}^{n} x_{i}} \right| + \left| \varepsilon_{+} 	\right|
		\\&\leq \left| \frac{\sum_{i=1}^{n-1}\left|x_{i}\varepsilon_{xi}\right| + \sum_{i=2}^{n-2} \left| \varepsilon_{+i} \sum_{j=1}^{i} x_{j} \right|
		+
		\varepsilon_{+}
	}
	{\sum_{i=1}^{n} x_{i}} \right| 
	+
	\left| \frac{x_{n}\varepsilon\left(x_{n}\right)}{\sum_{i=1}^{n} x_{i}} \right| + \left| \varepsilon_{+} \right|
	\\&\leq 
	\left| 
	\frac{
		\sum_{i=1}^{n}\left|x_{i}\varepsilon_{xi} \right|
		+ 
		\sum_{i=2}^{n-2} \left| \varepsilon_{+i} \sum_{j=1}^{i} x_{j} \right|
		+
		\varepsilon_{+}
		\left| x_{n}\varepsilon\left(x_{n}\right) \right|
	}
	{\sum_{i=1}^{n} x_{i}}
	\right|
	+ \left| \varepsilon_{+} \right|
		\\&\leq 
	\left| 
	\frac{
		\sum_{i=1}^{n}\left|x_{i}\varepsilon_{xi} \right|
		+ 
		\sum_{i=2}^{n-1} \left| \varepsilon_{+i} \sum_{j=1}^{i} x_{j} \right|
	}
	{\sum_{i=1}^{n} x_{i}}
	\right|
	+ \left| \varepsilon_{+} \right|
	\hspace*{5cm}\blacksquare
	\end{split}
\end{equation}
\\Que es a lo que se quería llegar.

Al aplicar esta fórmula sobre la suma de términos $t_{i}(x)$ quedaría:

\begin{equation}
	\begin{split}
		\left| \varepsilon_{y(x)} \right| &\leq
		\left| 
		\frac{
			\sum_{i=1}^{n}\left|t_{i}(x)\varepsilon_{t_{i}(x)}  \right|
			+ 
			\sum_{i=2}^{n-1} \left| \varepsilon_{+i} \sum_{j=1}^{i} t_{j}(x) \right|
		}
		{\sum_{i=1}^{n} t_{i}(x)}
		\right|
		+ \left| \varepsilon_{+} \right|
		\\&\leq
		\left| 
		\frac{
			\sum_{i=1}^{n}\left|t_{i}(x)(6i-1)\varepsilon_{op} \right|
			+ 
			\sum_{i=2}^{n-1} \left| \varepsilon_{+i} \sum_{j=1}^{i} t_{j}(x) \right|
		}
		{\sum_{i=1}^{n} t_{i}(x)}
		\right|
		+ \left| \varepsilon_{+} \right|
	\end{split}
\end{equation}


Al trabajar con aritmética finita se puede acotar los errores de operación por:
\\
si se usa truncamento:
\\
$\left| \varepsilon_{op} \right| \leq 2^{-t}$
\\
si se redondea:
\\
$\left| \varepsilon_{op} \right| \leq \frac{1}{2} 2^{-t}$

Finalmente, la cota del error de la serie es:

\begin{equation}
	\left| \varepsilon_{y(x)} \right| \leq
	\left| 
		\frac{
			\sum_{i=1}^{n}\left| (-1)^i\frac{x^{2i}}{(2i)!}(6i-1)\varepsilon_{op} \right|
			+ 
			\sum_{i=2}^{n-1} \left| \varepsilon_{op} \sum_{j=1}^{i} (-1)^j\frac{x^{2j}}{(2j)!} \right|
		}
		{\sum_{i=1}^{n} (-1)^i\frac{x^{2i}}{(2i)!}}
		\right|
		+ \left| \varepsilon_{+} \right|
\end{equation}

\subsection{Implementación de los Algoritmos}

a implementación de los algoritmos constó de dos partes. Por un lado, se implementó un algoritmo que calcula la sumatoria que aproxima la serie de Maclaurin de la función \textit{coseno}. Por otro lado, se implementó una clase que brinda la aritmética de $t$ bits de precisión, donde $t \le 52$. Esta misma clase permite al algoritmo que calcula la sumatoria trabajar con aritmética de $t$ bits de precisión o con la precisión nativa del compilador.

\subsubsection{Implementación de la Sumatoria que Aproxima la Serie de Maclaurin}

Para calcular la sumatoria que aproxima la serie de Maclaurin se implement'o un algoritmo iterativo usando un ciclo para la suma de t'erminos $t_{i}(x)$. Se utilizó un if para detectar si el t'ermino $i$ ten'ia signo negativo o no, esto redujo el error ya que no se realiza la potencia que est'a en la formula: $(-1)^i$.

En la primera versión del c'odigo se calculaba el factorial de $2i$ para cada t'ermino lo cu'al hacía que el c'odigo fuera muy lento; y al mismo tiempo, pon'ia un l'imite m'aximo de c'alculo de 17 t'erminos, ya que el factorial de $2*17 = 34$ es un n'umero con 39 d'igitos que es la m'axima cantidad de d'igitos que entra en una varible de tipo unsigned long long.

Luego se decidi'o optimizar el c'odigo ``arrastrando`` el 'ultimo t'ermino calculado, ya que la f'ormula de cada t'ermino $t_{i}(x)$ se puede escribir de manera recursiva, y haciendo una inmersi'on de rango se puede convertirla en un algoritmo iterativo.

Esto resolvi'o el problema de poder calcular a lo sumo 17 t'erminos, haciendo que sea posible calcular la suma con m'as de 200 t'erminos y adem'as aument'o la velocidad del c'alculo.

\subsubsection{Implementación de la Aritmética de $t$ bits de Precisión}

Para implementar la aritmética de $t$ bits de precisión se creó una clase denominada \textit{Real}. Las instancias de esta clase representan valores de punto flotante donde sólo se almacenan $t$ bits de precisión de la mantisa.

Las instancias de la clase \textit{Real}, contienen un valor de tipo punto flotante de doble precisión donde se almacena el valor representado. Las instancias de la clase \textit{Real} son inmutables; es decir, una vez que se crean para representar un valor, no se puede modificar el valor que representan.

La clase \textit{Real} define las operaciones aritméticas básicas, tales como: suma, resta, producto y división. Estas operaciones no modifican sus operandos sino que crean una nueva instancia que representa el resultado de la operación. Esta instancia, lleva el valor de la mantisa de la instancia del tipo double que se le envía para que represente a la cantidad de bits que se ha especificado al ser construíada. Así mismo, cabe aclarar que la clase \textit{Real} posee dos modos de funcionamiento. La clase \textit{Real} puede truncar o redondear los valores a $t$ bits de precisión.
 
La clase permite que se cambie la precisión utilizada, y luego de que se fija una nueva precisión, todas las operaciones sobre instancias de la clase \textit{Real} trabajan con la precisión fijada. Así mismo, la clase \textit{Real} permite fijar el modo en que realiza las operaciones. Se puede seleccionar entre truncamiento o redondeo.

Por default, la clase \textit{Real} tiene un precisión igual a la precisión nativa del compilador, haciendo uso de los 52 bits que permite el tipo punto flotante de doble precisión para la mantisa. Esta característica de la clase \textit{Real} permite al código que implementa la sumatoria que aproxima la serie de Maclaurin de la función \textit{coseno} trabajar solamente utilizando instancias de la clase \textit{Real} y no con \textit{Real} para cuando se necesita aritmética de $t$ bits de precisión y con el tipo \textit{double} cuando se requiere utilizar la artimética de precisión nativa del compilador.

\subsection{Problemas con la Implementación}

El trabajo se ha desarrollado utilizando como plataformas los sistemas operativos MacOS X 10.6.8 y Ubuntu 11.04. En estos sistemas nuestra implementación funciona correctamente y pasan los tests de unidad que se han escrito. Sin embargo, dado que una de las pautas para la entrega del trabajo es que los ejecutables que componen al mismo deben funcionar en alguna de las computadoras que se encuentran en los laboratorios de la facultad; se decidió probar tanto la compilación como la ejecución de los mismos en un entorno similar al que se encuentra en las computadoras de los laboratorios de la facultad.

Para ello, se descargó Debian GNU/Linux 6.0.2 y se lo instaló en una máquina virtual para poder contar con un ambiente similar con el que se cuenta en los laboratorios de la facultad.

Se intentó que las condiciones de prueba fueran lo más asépticas posibles en el sentido de no instalar software innecesario por sobre la instalación estándar del sistema. Sólo se agregaron el compilador, y las herramientas para acceder al código del trabajo.

Se comenzó por compilar el trabajo en la máquina virtual que se creó con Debian GNU/Linux 6.0.2. Este proceso se completó con éxito y produjo los ejecutables que se esperaba. Luego, se procedió a la ejecución de los tests de unidad con los que cuenta el proyecto. Para nuestra sorpresa, varios tests fallaban. A la luz de este problema se decidió probar el código corriendo de manera nativa en lugar de en una máquina virtual, y se corrió en una de las máquinas de los laboratorioss de la facultad que corren Debian GNU/Linux. Desafortunadamente, se obtuvieron los mismos resultados, con lo que se descartó que pudiera ser un problema del software de virtualización.

La causa de los fallos en los tests de unidad se debía a problemas de precisión numérica de las operaciones. El problema que se presentaba era una terrible falta de precisión en las operaciones realizadas en el sistema en cuestión con respecto a los otros dos sistemas donde se había desarrollado el código del trabajo. Por ejemplo, había casos donde la precisión en el sistema Debian GNU/Linux no superaba los cuatro o cinco dígitos decimales mientras que tanto en MacOS X 10.6.8 y en Ubuntu 11.04 las mismas operaciones se realizaban con hasta once dígitos decimales de precisión.

Se realizaron varias pruebas para poder determinar las causas de este problema.  
Primero, se intentó utilizar ciertos flags de compilación de GCC que modifican el comportamiento del compilador al generar código de punto flotante. Sin embargo, estos tests no tuvieron un resultado positivo.

Luego, se compararon las versiones de los tres compiladores con los que se contaba. Si bien todos los sistemas cuentan con el mismo compilador(GCC); cada sistema posee una versión distinta del mismo. MacOS X 10.6.8 posee la versión más antigua, mientras que Ubuntu 11.04 posee la más nueva. Se descubrió que la versión de GCC que utiliza Debian estaba generando código para una arquitectura i486 en lugar de una arquitectura más moderna como en los otros dos casos(i686 en Ubuntu 11.04 y amd64 en MacOS X 10.6.8). Por este motivo, se decidió probar el funcionamiento con una versión de Debian GNU/Linux 6.0.2 para la arquitectura amd64. Nuevamente, los resultados fueron los mismos.

Por último, se decidió deshabilitar la opción de optimización que se estaba utilizando(-O2) en la llamada al compilador. Por suerte, esta prueba funcionó y los tests de unidad volvieron a pasar. Lamentablemente, esta ha sido la única forma que se encontró para hacer que el código de punto flotante generado por el compilador GCC que utiliza el sistema operativo Debian GNU/Linux 6.0.2 tuviera una precisión comparable a la de los otros dos sistemas donde se probó el código del trabajo.

Por los resultados obtenidos de las distintas pruebas que se han realizado, el problema por el cual los tests de unidad fallan en el sistema operativo Debian GNU/Linux 6.0.2 se debe a problemas en el generador/optimizador de código del compilador que se utiliza en dicho sistema operativo. La única manera en la que se ha podido obtener una precisión de punto flotante comparable a los otros sistemas es mediante la deshabilitación de las optimizaciones de código. Por este motivo, no se recomienda utilizar este sistema para la ejecución del código.

